//
//  ThreadC.c
//  ThreadPool
//
//  Created by mac on 2022/7/14.
//


#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "ThreadC.h"
// 任务结构体

const int NUMBER = 2;
typedef struct Task{
    void (*function)(void *arg);
    void *arg;
} Task;

// 线程池结构体
typedef struct ThreadPool{
    
    // 任务队列
    Task *taskQ;
    int queueCapacity;      // 容量
    int queueSize;          // 当前任务个数
    int queueFront;         // 队头
    int queueRear;          // 队尾
    
    // 线程ID
    pthread_t managerID;   // 管理者线程ID
    pthread_t *threadIDs;  // 工作的线程ID数组
    
    int minNum;            // 最小线程数量
    int maxNum;            // 最大线程数量
    int busyNum;           // 忙的线程个数
    int liveNum;           // 活着的线程个数
    int exitNum;           // 要销毁的线程个数
    
    pthread_mutex_t mutexPool;      // 互斥量 锁整个线程池
    pthread_mutex_t mutexBusyNum;   // 互斥量 锁忙的线程个数
    
    pthread_cond_t notFull;         // 条件变量 判断任务队列是不是满了
    pthread_cond_t notEmpty;        // 条件变量 判断任务队列是不是空了
    
    int shutDown;
    
} ThreadPool;


// 创建线程池并初始化
ThreadPool* threadPoolCreate(int min, int max, int queueSize)
{
    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
    
//TODO:
//    do{}while(0) 神来之笔
//    do{} 里面的代码只执行一次
//    如果出现异常跳出while， 在while后面进行资源释放
//    如果正常，走到do的最后面，return pool;
    
    do {
        if (NULL == pool) {
            printf("malloc threadpool fail... \n");
            break;;
        }
        
        // 初始化任务队列
        pool->taskQ = (Task*)malloc(sizeof(Task) * queueSize);
        pool->queueCapacity = queueSize;
        pool->queueSize = 0;
        pool->queueFront = 0;
        pool->queueRear = 0;
        
        // 初始化线程ID
        pool->managerID = 0;
        
        pool->threadIDs = (pthread_t*)malloc(sizeof(pthread_t) * max);
        if (NULL == pool->threadIDs) {
            printf("malloc threadIDs fail... \n");
            break;;
        }
        memset(pool->threadIDs, 0, sizeof(pthread_t) * max);
        
        pool->minNum = min;
        pool->maxNum = max;
        pool->busyNum = 0;
        pool->liveNum = min; // 和最小个数相等
        pool->exitNum = 0;
        
        // 初始化锁
        if(pthread_mutex_init(&pool->mutexPool, NULL) != 0 ||
           pthread_mutex_init(&pool->mutexBusyNum, NULL) != 0 ||
           pthread_cond_init(&pool->notFull, NULL) != 0 ||
           pthread_cond_init(&pool->notEmpty, NULL) != 0)
        {
            printf("creat mutex or cond fail... \n");
            break;
        }
        
        // 创建线程
        pthread_create(&pool->managerID, NULL, manager, pool);
        
        for (int i = 0; i < min; ++i) {
            pthread_create(&pool->threadIDs[i], NULL, worker, pool);
        }
        
        pool->shutDown = 0;
        
        return pool;
    } while (0);
    
    // breake 出来以后，要释放资源
    if (pool && pool->threadIDs) {
        free(pool->threadIDs);
    }
    if (pool && pool->taskQ) {
        free(pool->taskQ);
    }
    if (pool) {
        free(pool);
    }
    return NULL;
}

// 销毁线程池

// 给线程池添加任务

// 获取线程池里工作的线程个数

// 获取线程池里活着的的线程个数

void worker(void* arg)
{
    ThreadPool* pool = (ThreadPool*)arg;
    if (NULL == pool) {
        printf("arg is null... \n");
        return;
    }
    
    while (1) {
        pthread_mutex_lock(&pool->mutexPool);
        
        // 当前任务队列是否为空
        while (0 == pool->queueSize && !pool->shutDown) {
            // 如果为空，需要阻塞工作者线程
            /*
            调用 pthread_cond_wait 使线程阻塞在这个地方
            notEmpty 是条件变量，记录哪些线程被阻塞了
            当 notEmpty 不为空时，就会唤醒阻塞在 pthread_cond_wait 的线程
             */
            pthread_cond_wait(&pool->notEmpty, &pool->mutexPool);
            
            // 判断是不是要销毁线程
            if (pool->exitNum > 0) {
                pool->exitNum--;
                
                if (pool->liveNum > pool->minNum) {
                    pool->liveNum--;
                    pthread_mutex_unlock(&pool->mutexPool);
                    threadExit(pool);
                }
               
            }
            
        }
        
        
        // 不阻塞时，说明要开始消费了
        // 开始消费之前，要判断线程是否已经被关闭了
        if (pool->shutDown) {
            // 将线程的锁打开
            pthread_mutex_unlock(&pool->mutexPool);
            // 将本线程退出
            threadExit(pool);
        }
        
        // 正儿八经开始消费了
        // 从任务队列中取出任务
        Task task = pool->taskQ[pool->queueFront];
        // 移动队头
        pool->queueFront = (pool->queueFront + 1) % pool->queueCapacity;
        // 任务个数-1
        pool->queueSize--;
        // 解锁
        
        // 消费完了，唤醒阻塞的生产者线程
        pthread_cond_signal(&pool->notFull);
        
        pthread_mutex_unlock(&pool->mutexPool);
        
        printf("thread %ld start working... \n", pthread_self());
        // 处理忙的线程个数
        pthread_mutex_lock(&pool->mutexBusyNum);
        pool->busyNum++;
        pthread_mutex_unlock(&pool->mutexBusyNum);
        
        task.function(task.arg); // 通过函数指针进行调用
        // (*task.function)(task.arg); // 解引用，通过函数调用也可以
        free(task.arg);
        task.arg = NULL;
        
        // 处理忙的线程个数
        pthread_mutex_lock(&pool->mutexBusyNum);
        pool->busyNum--;
        pthread_mutex_unlock(&pool->mutexBusyNum);
        printf("thread %ld end working... \n", pthread_self());
    }

}

// 管理者线程
void manager(void* arg)
{
    ThreadPool* pool = (ThreadPool*) arg;
    if (NULL == pool) {
        printf("manager pool is null... \n");
        return;
    }
    
    while (!pool->shutDown) {
        // 每隔 3 秒检查一次
        sleep(3);
        
        // 取出线程池中任务的数量 和 当前线程的数量
        pthread_mutex_lock(&pool->mutexPool);
        int queueSize = pool->queueSize;
        int liveNum = pool->liveNum;
        pthread_mutex_unlock(&pool->mutexPool);
        
        // 取忙的线程的数量
        pthread_mutex_lock(&pool->mutexBusyNum);
        int busyNum = pool->busyNum;
        pthread_mutex_unlock(&pool->mutexBusyNum);
        
        // 添加线程
        // 当前任务个数>存活的线程数 && 存活的线程数<最大线程数
        if (queueSize > liveNum && liveNum < pool->maxNum) {
            int counter = 0;
            
            pthread_mutex_lock(&pool->mutexPool);
            for (int i = 0; i < pool->maxNum && counter < NUMBER
                 && pool->liveNum < pool->maxNum; ++i) {
                if (0 == pool->threadIDs[i]) {
                    pthread_create(&pool->threadIDs[i], NULL, worker, pool);
                    counter ++;
                    pool->liveNum++;
                }
            }
            pthread_mutex_unlock(&pool->mutexPool);
        }
        
        // 销毁线程
        // 忙的线程*2 < 存活的线程数 && 存活的线程>最小的线程数
        if (busyNum*2 < liveNum && liveNum < pool->minNum) {
            
            pthread_mutex_lock(&pool->mutexPool);
            pool->exitNum = NUMBER;
            pthread_mutex_unlock(&pool->mutexPool);
            // 引导工作线程自杀
            /*
            工作的线程，如果没有干活，则阻塞在了条件变量 notEmpty 上
            把 阻塞在 条件变量 notEmpty 上的线程唤醒，让它向下执行，自杀（自己主动退出）
             */
            
            for (int i = 0; i < NUMBER; ++i) {
                // 管理者线程的引导操作
                pthread_cond_signal(&pool->notEmpty); // notifyOne 至少唤醒1个阻塞在条件变量上的线程
                /*
                 唤醒的时候，会把 mutexPool 这把锁交给被唤醒的线程
                 被唤醒的线程拥有了 mutexPool 的所有权
                 所以该线程在退出的时候，要释放那把锁
                 */
                
                //pthread_cond_broadcast(&pool->notEmpty);// notifyAll 唤醒所有阻塞在条件变量上的线程
            }
            
        }
        
    }// end of while
    
    return;
}


void threadExit(ThreadPool* pool)
{
    pthread_t tid = pthread_self();
    for (int i = 0; i < pool->maxNum; ++i) {
        if (pool->threadIDs[i] == tid) {
            pool->threadIDs[i] = 0;
            printf("threadExit called, %id exting... \n", tid);
            
            break;
        }
    }
    
    pthread_exit(NULL);
}

// 给线程池添加任务
void threadPoolAdd(ThreadPool* pool, void(*func)(void*), void* arg)
{
    pthread_mutex_lock(&pool->mutexPool);
    // 判断任务队列是不是满了
    while (pool->queueSize == pool->queueCapacity && !pool->shutDown) {
        // 阻塞生产者线程
        pthread_cond_wait(&pool->notFull, &pool->mutexPool);
    }
    
    if (pool->shutDown) {
        pthread_mutex_unlock(&pool->mutexPool);
        return;
    }
    
    // 添加任务到任务队列的队尾
    pool->taskQ[pool->queueRear].function = func;
    pool->taskQ[pool->queueRear].arg = arg;
    pool->queueRear = (pool->queueRear + 1) % pool->queueCapacity;
    
    pool->queueSize++;
    
    // 唤醒阻塞在条件变量上的工作者线程
    pthread_cond_signal(&pool->notEmpty);
    
    
    
    pthread_mutex_unlock(&pool->mutexPool);
    
}


// 获取线程池里工作的线程个数
int threadPoolBusyName(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexBusyNum);
    int busyNumber = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexBusyNum);
    return busyNumber;
}
// 获取线程池里活着的的线程个数
int threadPoolLivaName(ThreadPool* pool)
{
    pthread_mutex_lock(&pool->mutexPool);
    int liveNumber = pool->busyNum;
    pthread_mutex_unlock(&pool->mutexPool);
    return liveNumber;
}

// 销毁线程池
int threadPoolDestroy(ThreadPool* pool)
{
    if (NULL == pool) {
        printf("pool is nil... \n");
        return -1;
    }
    
    // 关闭线程池
    pool->shutDown = 1;
    
    // 阻塞回收管理者线程
    pthread_join(pool->managerID, NULL);
    
    // 唤醒阻塞的消费者线程
    for (int i = 0; i < pool->liveNum; ++i) {
        pthread_cond_signal(&pool->notEmpty);
    }
    
    
    // 释放锁的资源
    pthread_mutex_destroy(&pool->mutexPool);
    pthread_mutex_destroy(&pool->mutexBusyNum);
    // 释放条件变量的资源
    pthread_cond_destroy(&pool->notEmpty);
    pthread_cond_destroy(&pool->notFull);
    
    
    // 释放堆内存
    if (pool->threadIDs) {
        free(pool->threadIDs);
    }
    if (pool->taskQ) {
        free(pool->taskQ);
    }
    free(pool);
    pool = NULL;
    
    return 0;
    
}

static void tsstFunc(void* arg)
{
    int num = *(int* )arg;
    printf("thread %ld is working, number = %d \n", pthread_self(), num);
}

void ThreadC_Test()
{
    // 创建线程池
    ThreadPool* pool = threadPoolCreate(3, 10, 100);
    for (int i = 0; i < 100; ++i) {
        int* num = (int*)malloc(sizeof(int));
        *num = i + 100;
        threadPoolAdd(pool, tsstFunc, num);
    }
    
    sleep(1);
    
    threadPoolDestroy(pool);
    
}
